home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 11 / FM Towns Free Software Collection 11.iso / t_os / tool / artemis2 / src / copy.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-01  |  18.5 KB  |  693 lines

  1. // 0423-36-6862 taguchi
  2. #define MODULE_COPY
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <winb.h>
  8. #include <te.h>
  9. #include <fntb.h>
  10. #include <gui.h>
  11. #include <egb.h>
  12. #include <wgb.h>
  13. #include <msdos.cf>
  14. #include "art.h"
  15. #include "guisub.h"
  16. #include "wgbmac.H"
  17.  
  18. #include "imagewin.h"
  19. #include "imgwin.h"
  20. #include "pensel.h"
  21. #include "colsel.h"
  22. #include "fifo.h"
  23. #include "subgrp.h"
  24. #include "desktop.h"
  25. #include "copy.h"
  26.  
  27. int input_rectarea(IMWIN *win, EVENT *ev_first)
  28. // first:最初のマウス座標
  29. // type:0=矩形
  30. {
  31.     imagewin_storeUndo(win);
  32.   // クリップ枠の設定
  33.     RM_setClipVisibleAllScr();
  34.     RM_setOriginZero();
  35.   // データ構造の初期化
  36.     int type = 0;
  37.     EVENT *ev = ev_first;
  38.     POINT cp = *(POINT*)&ev->info; // 現在のカーソル位置
  39.     POINT lastp = cp;
  40.     FRAME frSrc;      // コピー元領域を表す PIC 領域 (x,y,wid,ht)
  41.   // コピー元を指定するイベントループ
  42.     // 最初に指定された点が、コピー元の座標1
  43.     POINT srcStartPt;
  44.     imagewin_getPosFromMos(win, &cp, &srcStartPt);
  45.     BOOL fFirst = TRUE;
  46.     for (;;)
  47.     {
  48.       // カーソルの現在位置のオブジェクトID および IMWIN を得る
  49.         int curobj = RM_getObjFromPoint(&cp);
  50.         IMWIN* curwin = imagewin_getWinFromPart(curobj);
  51.       // ラバー描画
  52.         if (curwin == win && imagewin_PtInPic(curwin, &cp))
  53.         {
  54.             POINT p; imagewin_getPosFromMos(win,&cp,&p);
  55.             FRAME fr;
  56.             fr.X = _min(srcStartPt.x, p.x);
  57.             fr.Y = _min(srcStartPt.y, p.y);
  58.             fr.WID = abs(srcStartPt.x - p.x) + 1;
  59.             fr.HT = abs(srcStartPt.y - p.y) + 1;
  60.             imagewin_setBoxRubber(win, &fr);
  61.         }
  62.         else
  63.             imagewin_clearBoxRubber(win);
  64.       // 左ボタンがクリックされたら
  65.         if (!fFirst && ev->what == EVMOSDN && (ev->shift & SLEFTBTN) != 0)
  66.         {
  67.             if (curwin == win && imagewin_PtInPic(win, &cp))
  68.             {
  69.                 imagewin_clearBoxRubber(win);
  70.               // コピー元領域が決定したので次にすすむ
  71.                 POINT p1;
  72.                 imagewin_getPosFromMos(win, &cp, &p1);
  73.                 if (p1.x < srcStartPt.x)
  74.                     SWAP_INT(p1.x, srcStartPt.x)
  75.                 if (p1.y < srcStartPt.y)
  76.                     SWAP_INT(p1.y, srcStartPt.y)
  77.                 frSrc.X = srcStartPt.x;
  78.                 frSrc.Y = srcStartPt.y;
  79.                 frSrc.WID = p1.x - srcStartPt.x + 1;
  80.                 frSrc.HT  = p1.y - srcStartPt.y + 1;
  81.                 lastp = cp;
  82.                 break;
  83.             }
  84.             else if (curwin != NULL)
  85.                 MMI_ExecEvnt(ev);
  86.         }
  87.       // 右ボタンがクリックされたら終了
  88.         else if (ev->what == EVMOSDN && (ev->shift & SRIGHTBTN) != 0)
  89.         {
  90.             imagewin_clearBoxRubber(win);
  91.             goto ENDCOPY;
  92.         }
  93.       // イベントセンス
  94.         do {
  95.             MMI_iosense();
  96.         } while (MMI_GetEvnt(EVALL, &ev) != NOERR);
  97.         fFirst = FALSE;
  98.       // イベント種別、シフト状態、マウス座標を得る
  99.         cp = *(POINT *) &ev->info;
  100.     }
  101.   // コピー先を指定するイベントループ
  102.     // コピー元のラバーを設定
  103.     imagewin_setBoxRubber(win, &frSrc);
  104.     fFirst = TRUE;
  105.     IMWIN* rubberwin = NULL;
  106.       for (;;)
  107.       {
  108.       // カーソルの現在位置のオブジェクトID および IMWIN を得る
  109.         int curobj = RM_getObjFromPoint(&cp);
  110.         IMWIN* curwin = imagewin_getWinFromPart(curobj);
  111.       // ラバー描画
  112.         if (curwin != NULL && imagewin_PtInPic(curwin, &cp))
  113.         {
  114.             POINT p; imagewin_getPosFromMos(curwin,&cp,&p);
  115.             FRAME fr = {p.x, p.y, frSrc.WID, frSrc.HT};
  116.             if (rubberwin != NULL && rubberwin != curwin)
  117.                 imagewin_clearBoxRubber2(rubberwin);
  118.             imagewin_setBoxRubber2(curwin, &fr);
  119.             rubberwin = curwin;
  120.         }
  121.         else if (rubberwin != NULL)
  122.         {
  123.             imagewin_clearBoxRubber2(rubberwin);
  124.             rubberwin = NULL;
  125.         }
  126.       // 左ボタンがクリックされたら
  127.         if (!fFirst && ev->what == EVMOSDN && (ev->shift & SLEFTBTN) != 0)
  128.         {
  129.             if (curwin != NULL && imagewin_PtInPic(curwin,&cp))
  130.             {
  131.                 if (rubberwin != NULL)
  132.                     imagewin_clearBoxRubber2(rubberwin);
  133.                 imagewin_clearBoxRubber(win);
  134.                 POINT ptDest;
  135.                 imagewin_getPosFromMos(curwin, &cp, &ptDest);
  136.                 imagewin_copy(win,&frSrc,curwin,&ptDest);
  137.                 imagewin_setBoxRubber(win, &frSrc);
  138.             }
  139.             else if (curwin != NULL)
  140.                 MMI_ExecEvnt(ev);
  141.         }
  142.       // 右ボタンがクリックされたら終了
  143.         else if (ev->what == EVMOSDN && (ev->shift & SRIGHTBTN) != 0)
  144.         {
  145.             if (rubberwin != NULL)
  146.                 imagewin_clearBoxRubber2(rubberwin);
  147.             imagewin_clearBoxRubber(win);
  148.             goto ENDCOPY;
  149.         }
  150.       // イベントセンス
  151.         do {
  152.             MMI_iosense();
  153.         } while (MMI_GetEvnt(EVALL, &ev) != NOERR);
  154.         fFirst = FALSE;
  155.       // 現在のカーソル位置を得る
  156.         cp = *(POINT *)&ev->info;
  157.       }
  158. ENDCOPY:;
  159.   // クリップ枠の復帰
  160.     RM_recoverOrigin();
  161.     RM_recoverClipVisible() ;
  162.   // 次に続くイベントをキューに積む
  163.     EVENT evbuf;
  164.     evbuf = *ev;
  165.     evbuf.what = EVMOSUP;
  166.     evbuf.shift = (evbuf.shift & (~SRIGHTBTN)) | SLEFTBTN;
  167.     MMI_SetEvnt(&evbuf);
  168.     return NOERR ;
  169. }
  170.  
  171. int cmd_rectzoomcopy(IMWIN *win, EVENT *ev_first)
  172. // first:最初のマウス座標
  173. // type:0=矩形
  174. {
  175.     imagewin_storeUndo(win);
  176.   // クリップ枠の設定
  177.     RM_setClipVisibleAllScr();
  178.     RM_setOriginZero();
  179.   // データ構造の初期化
  180.     int type = 0;
  181.     EVENT *ev = ev_first;
  182.     POINT cp = *(POINT*)&ev->info; // 現在のカーソル位置
  183.     POINT lastp = cp;
  184.     FRAME frSrc;      // コピー元領域を表す PIC 領域 (x,y,wid,ht)
  185.   // コピー元を指定するイベントループ
  186.     // 最初に指定された点が、コピー元の座標1
  187.     POINT srcStartPt;
  188.     imagewin_getPosFromMos(win, &cp, &srcStartPt);
  189.     BOOL fFirst = TRUE;
  190.     for (;;)
  191.     {
  192.       // カーソルの現在位置のオブジェクトID および IMWIN を得る
  193.         int curobj = RM_getObjFromPoint(&cp);
  194.         IMWIN* curwin = imagewin_getWinFromPart(curobj);
  195.       // ラバー描画
  196.         if (curwin == win && imagewin_PtInPic(curwin, &cp))
  197.         {
  198.             POINT p; imagewin_getPosFromMos(win,&cp,&p);
  199.             FRAME fr;
  200.             fr.X = _min(srcStartPt.x, p.x);
  201.             fr.Y = _min(srcStartPt.y, p.y);
  202.             fr.WID = abs(srcStartPt.x - p.x) + 1;
  203.             fr.HT = abs(srcStartPt.y - p.y) + 1;
  204.             imagewin_setBoxRubber(win, &fr);
  205.         }
  206.         else
  207.             imagewin_clearBoxRubber(win);
  208.       // 左ボタンがクリックされたら
  209.         if (!fFirst && ev->what == EVMOSDN && (ev->shift & SLEFTBTN) != 0)
  210.         {
  211.             if (curwin == win && imagewin_PtInPic(win, &cp))
  212.             {
  213.                 imagewin_clearBoxRubber(win);
  214.               // コピー元領域が決定したので次にすすむ
  215.                 POINT p1;
  216.                 imagewin_getPosFromMos(win, &cp, &p1);
  217.                 if (p1.x < srcStartPt.x)
  218.                     SWAP_INT(p1.x, srcStartPt.x)
  219.                 if (p1.y < srcStartPt.y)
  220.                     SWAP_INT(p1.y, srcStartPt.y)
  221.                 frSrc.X = srcStartPt.x;
  222.                 frSrc.Y = srcStartPt.y;
  223.                 frSrc.WID = p1.x - srcStartPt.x + 1;
  224.                 frSrc.HT  = p1.y - srcStartPt.y + 1;
  225.                 lastp = cp;
  226.                 break;
  227.             }
  228.             else if (curwin != NULL)
  229.                 MMI_ExecEvnt(ev);
  230.         }
  231.       // 右ボタンがクリックされたら終了
  232.         else if (ev->what == EVMOSDN && (ev->shift & SRIGHTBTN) != 0)
  233.         {
  234.             imagewin_clearBoxRubber(win);
  235.             goto ENDCOPY;
  236.         }
  237.       // イベントセンス
  238.         do {
  239.             MMI_iosense();
  240.         } while (MMI_GetEvnt(EVALL, &ev) != NOERR);
  241.         fFirst = FALSE;
  242.       // イベント種別、シフト状態、マウス座標を得る
  243.         cp = *(POINT *) &ev->info;
  244.     }
  245.   // コピー先を指定するイベントループ
  246.     // コピー元のラバーを設定
  247.     imagewin_setBoxRubber(win, &frSrc);
  248.  
  249.     IMWIN* destWin = NULL;
  250.     fFirst = TRUE;
  251.     POINT destStartPt;
  252.     for (;;)
  253.     {
  254.       // カーソルの現在位置のオブジェクトID および IMWIN を得る
  255.         int curobj = RM_getObjFromPoint(&cp);
  256.         IMWIN* curwin = imagewin_getWinFromPart(curobj);
  257.       // ラバー描画
  258.         if (curwin == destWin && imagewin_PtInPic(curwin, &cp))
  259.         {
  260.             POINT p; imagewin_getPosFromMos(destWin,&cp,&p);
  261.             FRAME fr;
  262.             fr.X = _min(destStartPt.x, p.x);
  263.             fr.Y = _min(destStartPt.y, p.y);
  264.             fr.WID = abs(destStartPt.x - p.x) + 1;
  265.             fr.HT = abs(destStartPt.y - p.y) + 1;
  266.             imagewin_setBoxRubber2(destWin, &fr);
  267.         }
  268.         else if (destWin != NULL)
  269.             imagewin_clearBoxRubber2(destWin);
  270.       // 左ボタンがクリックされたら
  271.         if (!fFirst && ev->what == EVMOSDN && (ev->shift & SLEFTBTN) != 0)
  272.         {
  273.             if (destWin == NULL)
  274.                 // コピー先の始点が決定
  275.             {
  276.  
  277.             }
  278.  
  279.  
  280.             if (curwin == win && imagewin_PtInPic(win, &cp))
  281.             {
  282.                 imagewin_clearBoxRubber(win);
  283.               // コピー元領域が決定したので次にすすむ
  284.                 POINT p1;
  285.                 imagewin_getPosFromMos(win, &cp, &p1);
  286.                 if (p1.x < srcStartPt.x)
  287.                     SWAP_INT(p1.x, srcStartPt.x)
  288.                 if (p1.y < srcStartPt.y)
  289.                     SWAP_INT(p1.y, srcStartPt.y)
  290.                 frSrc.X = srcStartPt.x;
  291.                 frSrc.Y = srcStartPt.y;
  292.                 frSrc.WID = p1.x - srcStartPt.x + 1;
  293.                 frSrc.HT  = p1.y - srcStartPt.y + 1;
  294.                 lastp = cp;
  295.                 break;
  296.             }
  297.             else if (curwin != NULL)
  298.                 MMI_ExecEvnt(ev);
  299.         }
  300.       // 右ボタンがクリックされたら終了
  301.         else if (ev->what == EVMOSDN && (ev->shift & SRIGHTBTN) != 0)
  302.         {
  303.             imagewin_clearBoxRubber(win);
  304.             goto ENDCOPY;
  305.         }
  306.       // イベントセンス
  307.         do {
  308.             MMI_iosense();
  309.         } while (MMI_GetEvnt(EVALL, &ev) != NOERR);
  310.         fFirst = FALSE;
  311.       // イベント種別、シフト状態、マウス座標を得る
  312.         cp = *(POINT *) &ev->info;
  313.     }
  314.  
  315.  
  316.  
  317.     fFirst = TRUE;
  318.     IMWIN* rubberwin = NULL;
  319.       for (;;)
  320.       {
  321.       // カーソルの現在位置のオブジェクトID および IMWIN を得る
  322.         int curobj = RM_getObjFromPoint(&cp);
  323.         IMWIN* curwin = imagewin_getWinFromPart(curobj);
  324.       // ラバー描画
  325.         if (curwin != NULL && imagewin_PtInPic(curwin, &cp))
  326.         {
  327.             POINT p; imagewin_getPosFromMos(curwin,&cp,&p);
  328.             FRAME fr = {p.x, p.y, frSrc.WID, frSrc.HT};
  329.             if (rubberwin != NULL && rubberwin != curwin)
  330.                 imagewin_clearBoxRubber2(rubberwin);
  331.             imagewin_setBoxRubber2(curwin, &fr);
  332.             rubberwin = curwin;
  333.         }
  334.         else if (rubberwin != NULL)
  335.         {
  336.             imagewin_clearBoxRubber2(rubberwin);
  337.             rubberwin = NULL;
  338.         }
  339.       // 左ボタンがクリックされたら
  340.         if (!fFirst && ev->what == EVMOSDN && (ev->shift & SLEFTBTN) != 0)
  341.         {
  342.             if (curwin != NULL && imagewin_PtInPic(curwin,&cp))
  343.             {
  344.                 if (rubberwin != NULL)
  345.                     imagewin_clearBoxRubber2(rubberwin);
  346.                 imagewin_clearBoxRubber(win);
  347.                 POINT ptDest;
  348.                 imagewin_getPosFromMos(curwin, &cp, &ptDest);
  349.                 imagewin_copy(win,&frSrc,curwin,&ptDest);
  350.                 imagewin_setBoxRubber(win, &frSrc);
  351.             }
  352.             else if (curwin != NULL)
  353.                 MMI_ExecEvnt(ev);
  354.         }
  355.       // 右ボタンがクリックされたら終了
  356.         else if (ev->what == EVMOSDN && (ev->shift & SRIGHTBTN) != 0)
  357.         {
  358.             if (rubberwin != NULL)
  359.                 imagewin_clearBoxRubber2(rubberwin);
  360.             imagewin_clearBoxRubber(win);
  361.             goto ENDCOPY;
  362.         }
  363.       // イベントセンス
  364.         do {
  365.             MMI_iosense();
  366.         } while (MMI_GetEvnt(EVALL, &ev) != NOERR);
  367.         fFirst = FALSE;
  368.       // 現在のカーソル位置を得る
  369.         cp = *(POINT *)&ev->info;
  370.       }
  371. ENDCOPY:;
  372.   // クリップ枠の復帰
  373.     RM_recoverOrigin();
  374.     RM_recoverClipVisible() ;
  375.   // 次に続くイベントをキューに積む
  376.     EVENT evbuf;
  377.     evbuf = *ev;
  378.     evbuf.what = EVMOSUP;
  379.     evbuf.shift = (evbuf.shift & (~SRIGHTBTN)) | SLEFTBTN;
  380.     MMI_SetEvnt(&evbuf);
  381.     return NOERR ;
  382. }
  383.  
  384.  
  385. int input_polygonarea(IMWIN *win, EVENT *ev_first)
  386. // first:最初のマウス座標
  387. // type:0=矩形
  388. {
  389.     imagewin_storeUndo(win);
  390.   // クリップ枠の設定
  391.     RM_setClipVisibleAllScr();
  392.     RM_setOriginZero();
  393.   // データ構造の初期化
  394.     int type = 0;
  395.     EVENT *ev = ev_first;
  396.     POINT cp = *(POINT*)&ev->info; // 現在のカーソル位置
  397.     #define MAXPOINT 2000
  398.     POINT *points = TL_calloc(sizeof(POINT), MAXPOINT);
  399.     int nPoint = 0;
  400.     if (points == NULL)
  401.         goto ENDCOPY;
  402.     POINT lastp = cp;
  403.     POINT lastPicPt;  imagewin_getPosFromMos(win, &lastp, &lastPicPt);
  404.     FRAME frSrc = {lastPicPt.x,lastPicPt.y,lastPicPt.x,lastPicPt.y};
  405.     AREA areaSrc = NULL;
  406.     // 更新中は (x1,y1,x2,y2) 形式
  407.     void updateFrSrc(POINT* pt)
  408.     {
  409.         frSrc.X = _min(frSrc.X, pt->x);
  410.         frSrc.Y = _min(frSrc.Y, pt->y);
  411.         frSrc.X2 = _max(frSrc.X2, pt->x);
  412.         frSrc.Y2 = _max(frSrc.Y2, pt->y);
  413.     }
  414.   // 最初の点を座標配列に登録
  415.     points[nPoint++] = lastPicPt;
  416.   // コピー元を指定するイベントループ
  417.     BOOL fFirst = TRUE;
  418.     for (;;)
  419.     {
  420.       // カーソルの現在位置のオブジェクトID および IMWIN を得る
  421.         int curobj = RM_getObjFromPoint(&cp);
  422.         IMWIN* curwin = imagewin_getWinFromPart(curobj);
  423.       // ラバー描画
  424.         if (curwin == win && imagewin_PtInPic(curwin, &cp))
  425.         {
  426.             imagewin_resetLineRubber2(win);
  427.             POINT p2;
  428.             imagewin_getPosFromMos(win, &cp, &p2);
  429.             imagewin_addLineRubber2(win, &lastPicPt, &p2);
  430.         }
  431.         else
  432.         {
  433.             imagewin_resetLineRubber2(win);
  434.             imagewin_updateScr(win);
  435.         }
  436.       // 左ボタンがクリックされたら
  437.         if (!fFirst && (ev->what == EVMOSDN || ev->what == EVMOSDRAG)
  438.             && (ev->shift & SLEFTBTN) != 0)
  439.         {
  440.             if (curwin == win && imagewin_PtInPic(win, &cp))
  441.             {
  442.                 imagewin_resetLineRubber2(win);
  443.               // ラバー追加
  444.                 POINT p2;
  445.                 imagewin_getPosFromMos(win, &cp, &p2);
  446.                 imagewin_addLineRubber(win, &lastPicPt, &p2);
  447.                 updateFrSrc(&p2);
  448.                 points[nPoint++] = p2;
  449.                 lastPicPt = p2;
  450.                 lastp = cp;
  451.             }
  452.             else if (curwin != NULL)
  453.                 MMI_ExecEvnt(ev);
  454.         }
  455.       // 右ボタンがクリックされたら終了
  456.         else if (ev->what == EVMOSDN && (ev->shift & SRIGHTBTN) != 0)
  457.         {
  458.             imagewin_resetLineRubber2(win);
  459.             if (imagewin_nLineRubber(win) >= 2)
  460.             {
  461.               // ラバー追加
  462.                 imagewin_addLineRubber(win, &lastPicPt, NULL);
  463.                 imagewin_updateScr(win);
  464.                 break;
  465.             }
  466.             else
  467.             {
  468.                 imagewin_resetLineRubber(win);
  469.                 imagewin_updateScr(win);
  470.                 goto ENDCOPY;
  471.             }
  472.         }
  473.       // イベントセンス
  474.         do {
  475.             MMI_iosense();
  476.         } while (MMI_GetEvnt(EVALL, &ev) != NOERR);
  477.         fFirst = FALSE;
  478.       // イベント種別、シフト状態、マウス座標を得る
  479.         cp = *(POINT *) &ev->info;
  480.     }
  481.   // frSrc を (x,y,wid,ht) 形式に変更
  482.     SortRect((Rect*)&frSrc);
  483.     frSrc.WID = frSrc.X2 - frSrc.X + 1;
  484.     frSrc.HT  = frSrc.Y2 - frSrc.Y + 1;
  485.   // areaSrc を作成
  486.     areaSrc = area_new(frSrc.X, frSrc.Y, frSrc.WID, frSrc.HT);
  487.     if (areaSrc == NULL)
  488.         goto ENDCOPY;
  489.     area_polygon(areaSrc, points, nPoint);
  490.   // コピー先を指定するイベントループ
  491.     fFirst = TRUE;
  492.     IMWIN* rubberwin = NULL;
  493.       for (;;)
  494.       {
  495.       // カーソルの現在位置のオブジェクトID および IMWIN を得る
  496.         int curobj = RM_getObjFromPoint(&cp);
  497.         IMWIN* curwin = imagewin_getWinFromPart(curobj);
  498.       // ラバー描画
  499.         if (curwin != NULL && imagewin_PtInPic(curwin, &cp))
  500.         {
  501.             POINT p; imagewin_getPosFromMos(curwin,&cp,&p);
  502.             FRAME fr = {p.x, p.y, frSrc.WID, frSrc.HT};
  503.             if (rubberwin != NULL && rubberwin != curwin)
  504.                 imagewin_clearBoxRubber2(rubberwin);
  505.             imagewin_setBoxRubber2(curwin, &fr);
  506.             rubberwin = curwin;
  507.         }
  508.         else if (rubberwin != NULL)
  509.         {
  510.             imagewin_clearBoxRubber2(rubberwin);
  511.             rubberwin = NULL;
  512.         }
  513.       // 左ボタンがクリックされたら
  514.         if (!fFirst && ev->what == EVMOSDN && (ev->shift & SLEFTBTN) != 0)
  515.         {
  516.             if (curwin != NULL && imagewin_PtInPic(curwin,&cp))
  517.             {
  518.                 if (rubberwin != NULL)
  519.                     imagewin_clearBoxRubber2(rubberwin);
  520.                 POINT ptDest;
  521.                 imagewin_getPosFromMos(curwin, &cp, &ptDest);
  522.                 imagewin_copyarea(win, areaSrc, curwin, &ptDest);
  523.             }
  524.             else if (curwin != NULL)
  525.                 MMI_ExecEvnt(ev);
  526.         }
  527.       // 右ボタンがクリックされたら終了
  528.         else if (!fFirst && ev->what==EVMOSDN && (ev->shift & SRIGHTBTN) != 0)
  529.         {
  530.             if (rubberwin != NULL)
  531.                 imagewin_clearBoxRubber2(rubberwin);
  532.             break;
  533.         }
  534.       // イベントセンス
  535.         do {
  536.             MMI_iosense();
  537.         } while (MMI_GetEvnt(EVALL, &ev) != NOERR);
  538.         fFirst = FALSE;
  539.       // 現在のカーソル位置を得る
  540.         cp = *(POINT *)&ev->info;
  541.       }
  542. ENDCOPY:;
  543.     imagewin_resetLineRubber(win);
  544.     imagewin_updateScr(win);
  545.     if (areaSrc != NULL)
  546.         area_delete(areaSrc);
  547.     if (points != NULL)
  548.         TL_free(points);
  549.   // クリップ枠の復帰
  550.     RM_recoverOrigin();
  551.     RM_recoverClipVisible() ;
  552.   // 次に続くイベントをキューに積む
  553.     EVENT evbuf;
  554.     evbuf = *ev;
  555.     evbuf.what = EVMOSUP;
  556.     evbuf.shift = (evbuf.shift & (~SRIGHTBTN)) | SLEFTBTN;
  557.     MMI_SetEvnt(&evbuf);
  558.     return NOERR ;
  559. }
  560.  
  561. int cmd_polygonfill(IMWIN *win, EVENT *ev_first)
  562. // first:最初のマウス座標
  563. // type:0=矩形
  564. {
  565.     imagewin_storeUndo(win);
  566.   // クリップ枠の設定
  567.     RM_setClipVisibleAllScr();
  568.     RM_setOriginZero();
  569.   // データ構造の初期化
  570.     int type = 0;
  571.     EVENT *ev = ev_first;
  572.     POINT cp = *(POINT*)&ev->info; // 現在のカーソル位置
  573.     #define MAXPOINT 2000
  574.     POINT *points = TL_calloc(sizeof(POINT), MAXPOINT);
  575.     int nPoint = 0;
  576.     if (points == NULL)
  577.         goto ENDCOPY;
  578.     POINT lastp = cp;
  579.     POINT lastPicPt;  imagewin_getPosFromMos(win, &lastp, &lastPicPt);
  580.     FRAME frSrc = {lastPicPt.x,lastPicPt.y,lastPicPt.x,lastPicPt.y};
  581.     AREA areaSrc = NULL;
  582.     // 更新中は (x1,y1,x2,y2) 形式
  583.     void updateFrSrc(POINT* pt)
  584.     {
  585.         frSrc.X = _min(frSrc.X, pt->x);
  586.         frSrc.Y = _min(frSrc.Y, pt->y);
  587.         frSrc.X2 = _max(frSrc.X2, pt->x);
  588.         frSrc.Y2 = _max(frSrc.Y2, pt->y);
  589.     }
  590.   // 最初の点を座標配列に登録
  591.     points[nPoint++] = lastPicPt;
  592.   // コピー元を指定するイベントループ
  593.     BOOL fFirst = TRUE;
  594.     for (;;)
  595.     {
  596.       // カーソルの現在位置のオブジェクトID および IMWIN を得る
  597.         int curobj = RM_getObjFromPoint(&cp);
  598.         IMWIN* curwin = imagewin_getWinFromPart(curobj);
  599.       // ラバー描画
  600.         if (curwin == win && imagewin_PtInPic(curwin, &cp))
  601.         {
  602.             imagewin_resetLineRubber2(win);
  603.             POINT p2;
  604.             imagewin_getPosFromMos(win, &cp, &p2);
  605.             imagewin_addLineRubber2(win, &lastPicPt, &p2);
  606.         }
  607.         else
  608.         {
  609.             imagewin_resetLineRubber2(win);
  610.             imagewin_updateScr(win);
  611.         }
  612.       // 左ボタンがクリックされたら
  613.         if (!fFirst && (ev->what == EVMOSDN || ev->what == EVMOSDRAG)
  614.             && (ev->shift & SLEFTBTN) != 0)
  615.         {
  616.             if (curwin == win && imagewin_PtInPic(win, &cp))
  617.             {
  618.                 imagewin_resetLineRubber2(win);
  619.               // ラバー追加
  620.                 POINT p2;
  621.                 imagewin_getPosFromMos(win, &cp, &p2);
  622.                 imagewin_addLineRubber(win, &lastPicPt, &p2);
  623.                 updateFrSrc(&p2);
  624.                 points[nPoint++] = p2;
  625.                 lastPicPt = p2;
  626.                 lastp = cp;
  627.             }
  628.             else if (curwin != NULL)
  629.                 MMI_ExecEvnt(ev);
  630.         }
  631.       // 右ボタンがクリックされたら終了
  632.         else if (ev->what == EVMOSDN && (ev->shift & SRIGHTBTN) != 0)
  633.         {
  634.             imagewin_resetLineRubber2(win);
  635.             if (imagewin_nLineRubber(win) >= 2)
  636.             {
  637.               // ラバー追加
  638.                 imagewin_addLineRubber(win, &lastPicPt, NULL);
  639.                 imagewin_updateScr(win);
  640.                 break;
  641.             }
  642.             else
  643.             {
  644.                 imagewin_resetLineRubber(win);
  645.                 imagewin_updateScr(win);
  646.                 goto ENDCOPY;
  647.             }
  648.         }
  649.       // イベントセンス
  650.         do {
  651.             MMI_iosense();
  652.         } while (MMI_GetEvnt(EVALL, &ev) != NOERR);
  653.         fFirst = FALSE;
  654.       // イベント種別、シフト状態、マウス座標を得る
  655.         cp = *(POINT *) &ev->info;
  656.     }
  657.     imagewin_clearLineRubber(win);
  658.   // frSrc を (x,y,wid,ht) 形式に変更
  659.     SortRect((Rect*)&frSrc);
  660.     frSrc.WID = frSrc.X2 - frSrc.X + 1;
  661.     frSrc.HT  = frSrc.Y2 - frSrc.Y + 1;
  662.   // areaSrc を作成
  663.     areaSrc = area_new(frSrc.X, frSrc.Y, frSrc.WID, frSrc.HT);
  664.     if (areaSrc == NULL)
  665.         goto ENDCOPY;
  666.     area_polygon(areaSrc, points, nPoint);
  667.   // 領域塗りつぶし
  668.     PIXEL pix;
  669.     colsel_getPixel(&pix);
  670.     pic_beginUpDate(win->pic);
  671.     pic_fillarea(win->pic, areaSrc, &pix);
  672.     FRAME frUpdate;
  673.     pic_endUpDate(win->pic, &frUpdate);
  674.     imagewin_updateScrPart(win, &frUpdate);
  675. ENDCOPY:;
  676.     imagewin_resetLineRubber(win);
  677.     imagewin_updateScr(win);
  678.     if (areaSrc != NULL)
  679.         area_delete(areaSrc);
  680.     if (points != NULL)
  681.         TL_free(points);
  682.   // クリップ枠の復帰
  683.     RM_recoverOrigin();
  684.     RM_recoverClipVisible() ;
  685.   // 次に続くイベントをキューに積む
  686.     EVENT evbuf;
  687.     evbuf = *ev;
  688.     evbuf.what = EVMOSUP;
  689.     evbuf.shift = (evbuf.shift & (~SRIGHTBTN)) | SLEFTBTN;
  690.     MMI_SetEvnt(&evbuf);
  691.     return NOERR ;
  692. }
  693.